home *** CD-ROM | disk | FTP | other *** search
/ Language/OS - Multiplatform Resource Library / LANGUAGE OS.iso / scheme / pcscheme / geneva / sources.exe / SOURCES / BGI / PS.CPP < prev    next >
Encoding:
Text File  |  1993-03-25  |  13.7 KB  |  632 lines
  1. /************************************************************************
  2.  *            The C routines dispatched to            *
  3.  ************************************************************************/
  4.  
  5. #define    BREAKPOINT    asm int 3
  6. #define MK_FP( seg,ofs )( (void _seg * )( seg ) +( void near * )( ofs ))
  7. #define    STDOUT    1
  8. #define    HEX(c)        ((c)>9 ? (c)+'A'-10 : (c)+'0')
  9.  
  10. typedef    unsigned char    byte;
  11. typedef    unsigned _ss    &INT;
  12. typedef byte _ss    &BYTE;
  13. typedef    union {
  14.     unsigned    u;
  15.     byte        b[2];
  16.     } _ss        ®
  17. typedef    void far * _ss    &FP;
  18. typedef    byte far * _ss    &CP;
  19. typedef    enum { OK, ERROR }    RVALUE;
  20.  
  21. typedef void    (*HANDLER)(...);
  22.  
  23. typedef    struct {
  24.     char    *name;
  25.     struct {
  26.         int    reserved1;
  27.         int    ncols, nrows, pcols, prows;
  28.         int    width, height, ratio;
  29.         long    reserved2;
  30.         }    mode;
  31.     }    MODE;
  32.  
  33. typedef    struct {
  34.     byte    red, green, blue;
  35.     }    COLOR;
  36.  
  37. typedef    struct {
  38.     unsigned    width, height;
  39.     byte    data[];
  40.     }    IMAGE;
  41.  
  42. #define    PATLEN    8
  43. typedef    byte    PATTERN[PATLEN];
  44.  
  45. extern "C" void    emulate(...);
  46. extern "C" void    bitmaputl(...);
  47.  
  48. int    Mode;
  49. MODE    Modes[] = {
  50.     {"\022Postscript 100x100", { 0, 99, 99, 99, 99, 7000, 7000, 10000, 0x90900808 } },
  51.     {"\022Postscript 320x200", { 0, 319, 199, 319, 199, 11200, 7000, 10000, 0x90900808 } },
  52.     {"\022Postscript 640x480", { 0, 639, 479, 639, 479, 9333, 7000, 10000, 0x90900808 } },
  53.     {"\023Postscript 1024x768", { 0, 1023, 767, 1023, 767, 9333, 7000, 10000, 0x90900808 } },
  54.     {"\024Postscript 1024x1024", { 0, 1023, 1023, 1023, 1023, 7000, 7000, 10000, 0x90900808 } },
  55.     {"\024Postscript 2048x2048", { 0, 2047, 2047, 2047, 2047, 7000, 7000, 10000, 0x90900808 } },
  56.     {"\024Encapsulated 100x100", { 0, 99, 99, 99, 99, 7000, 7000, 10000, 0x90900808 } },
  57.     {"\024Encapsulated 320x200", { 0, 319, 199, 319, 199, 11200, 7000, 10000, 0x90900808 } },
  58.     {"\024Encapsulated 640x480", { 0, 639, 479, 639, 479, 9333, 7000, 10000, 0x90900808 } },
  59.     {"\025Encapsulated 1024x768", { 0, 1023, 767, 1023, 767, 9333, 7000, 10000, 0x90900808 } },
  60.     {"\026Encapsulated 1024x1024", { 0, 1023, 1023, 1023, 1023, 7000, 7000, 10000, 0x90900808 } },
  61.     {"\027Encapsulated 2048x2048", { 0, 2047, 2047, 2047, 2047, 7000, 7000, 10000, 0x90900808 } }
  62. };
  63. #define    MODENUM    (sizeof(Modes)/sizeof(MODE))
  64. COLOR    Fill = { 0, 0, 0 };        // we switch black and white
  65.  
  66. COLOR    Colors[0x100] = {
  67.     { 0xff, 0xff, 0xff },
  68.     { 0, 0, 0x80 },
  69.     { 0, 0x80, 0 },
  70.     { 0, 0x80, 0x80 },
  71.     { 0x80, 0, 0 },
  72.     { 0x80, 0, 0x80 },
  73.     { 0x80, 0x80, 0 },
  74.     { 0x80, 0x80, 0x80 },
  75.     { 0xc0, 0xc0, 0xc0 },
  76.     { 0, 0, 0xff },
  77.     { 0, 0xff, 0 },
  78.     { 0, 0xff, 0xff },
  79.     { 0xff, 0, 0 },
  80.     { 0xff, 0, 0xff },
  81.     { 0xff, 0xff, 0 },
  82.     { 0, 0, 0 },
  83.     };
  84. int    FXsize, FYsize, FDir, FFirst;
  85. unsigned    Handle;
  86.  
  87. unsigned    write( int fd, char far *buf )
  88. {
  89.     for( int len = 0; buf[len]; len++ );
  90. asm {
  91.     push    ds
  92.     mov    ah, 40h            // write
  93.     mov    bx, fd
  94.     mov    cx, len
  95.     lds    dx, buf
  96.     int    21h
  97.     pop    ds
  98.     jc    error
  99. }
  100.     return    _AX;
  101. error:
  102.     return    -1;
  103. }
  104.  
  105. unsigned    open( char far *s )
  106. {
  107.     if( *s == '*')
  108.     {
  109.         s++;
  110.         goto    failedopen;
  111.     }
  112. asm {
  113.     push    ds
  114.     mov    ax, 3d01h        // open for write
  115.     lds    dx, s
  116.     int    21h
  117.     pop    ds
  118.     jc    failedopen
  119.     push    ax
  120.     mov    bx, ax
  121.     mov    ax, 4202h        // seek to end
  122.     mov    cx, 0
  123.     mov    dx, 0
  124.     int    21h
  125.     pop    ax
  126. }
  127.     return    _AX;
  128. failedopen:
  129. asm {
  130.     push    ds
  131.     mov    ah, 3ch            // create
  132.     mov    cx, 0h
  133.     lds    dx, s
  134.     int    21h
  135.     pop    ds
  136.     jc    failedcreate
  137. }
  138.     return    _AX;
  139. failedcreate:
  140.     return    0;
  141. }
  142.  
  143. void    close( unsigned handle )
  144. {
  145. asm {
  146.     mov    ah, 3eh            // close
  147.     mov    bx, handle
  148.     int    21h
  149. }
  150. }
  151.  
  152. char _ss    *putint( char _ss *p, unsigned n, unsigned base )
  153. {
  154.     if( base == 10 && n > 32768 )
  155.     {
  156.         *p++ = '-';
  157.         return    putint( p, -n, base );
  158.     }
  159.     if( n >= base )
  160.         p = putint( p, n / base, base );
  161.     *p++ = HEX( n % base );
  162.     return    p;
  163. }
  164.  
  165. void    printf( int stream, char *format, ... )
  166. {
  167.     char    s[0x100], _ss *p;
  168.     int _ss    *arg = ...;
  169.  
  170.     for( p = s; *format; format++ )
  171.     if( *format == '%')
  172.     {
  173.         if( *++format == '%')
  174.             *p++ = *format;
  175.         else switch( *format )
  176.         {
  177.         case 'c':
  178.             *p++ = *arg++;
  179.             break;
  180.         case 'd':
  181.             p = putint( p, *arg++, 10 );
  182.             break;
  183.         case 'x':
  184.             p = putint( p, *arg++, 16 );
  185.             break;
  186.         case 's':
  187.         {
  188.             int    ofs = *arg++;
  189.             char far *q = (char _seg *) *arg++ + ofs;
  190.  
  191.             while( (*p++ = *q++) != 0 );
  192.             p--;
  193.         }
  194.         }
  195.     }
  196.     else    *p++ = *format;
  197.     *p = 0;
  198.     write( stream, s );
  199. }
  200.  
  201. void    puthex( byte c )
  202. {
  203.     printf( Handle, "%c%c", HEX( c & 0x0f ), HEX( c >> 4 ) );
  204. }
  205.  
  206. char far    *getenv( char *s )
  207. {
  208.     unsigned    psp;
  209.     char far     *env;
  210.     char    *t;
  211. asm {
  212.     mov    ah, 62h            // get psp
  213.     int    21h
  214. }
  215.     psp = _BX;
  216.     env = (char far *) MK_FP( *( (unsigned far *) MK_FP( psp, 0x2c )), 0 );
  217.  
  218.     while( *env )
  219.     {
  220.         for( t = s; *t; t++ )
  221.         if( *t != *env++ )
  222.             goto    failed;
  223.         if( *env++ == '=')
  224.             return    env;
  225. failed:
  226.         while( *env )
  227.             env++;
  228.         env++;
  229.     }
  230.     return    0;
  231. }
  232.  
  233. void    setcolor( COLOR &c )
  234. {
  235.     printf( Handle, "%d 255 div %d 255 div %d 255 div setrgbcolor\r\n",
  236.         c.red, c.green, c.blue );
  237. }
  238.  
  239. void    fill(void)
  240. {
  241.     printf( Handle, "%% /Pattern setcolorspace Pattern setcolor\r\n");
  242.     setcolor( Fill );
  243.     
  244.     printf( Handle, "fill ");
  245. }
  246.  
  247. RVALUE    install( BYTE subfunc, REG, BYTE mode, REG, FP string )
  248. {
  249.     for( int i = 0x10; i < 0x100; i++ )    // duplicate
  250.         Colors[i] = Colors[i & 0xf];
  251.  
  252.     switch( subfunc )
  253.     {
  254.     case 0:                // perform init
  255.         string = &Modes[Mode = mode].mode;
  256.         break;
  257.     case 1:                // get maximum mode in 'mode'
  258.         mode = MODENUM;
  259.         break;
  260.     case 2:                // get string for 'mode' in 'string'
  261.         string = Modes[mode].name;
  262.     }
  263.     return    OK;
  264. }
  265.  
  266. void    init()
  267. {
  268.     {
  269.         char far    *name = getenv("PS$");
  270.         if( name )
  271.             Handle = open(name);
  272.         else    Handle = 0;
  273.         if( !Handle )
  274.             Handle = STDOUT;
  275.     }
  276.  
  277.     if( Mode >= MODENUM / 2 )    // encapsulated
  278.     {
  279.         printf( Handle, "%%!PS-Adobe-2.0 EPSF-2.0\r\n"
  280.             "%%%%BoundingBox: 0 0 %d %d\r\n"
  281.             "%%%%Creator: Larry Bartholdi & his gang\r\n"
  282.             "%%%%DocumentFonts: Helvetica\r\n"
  283.             "%%%%LanguageLevel: 1\r\n"
  284.             "%%%%Orientation: Portrait\r\n"
  285.             "%%%%EndComments\r\n",
  286.             Modes[Mode].mode.width / 14,
  287.             Modes[Mode].mode.height / 14 );
  288.         printf( Handle, "gsave %d %d div -%d %d div scale\r\n",
  289.             Modes[Mode].mode.width / 14, Modes[Mode].mode.ncols,
  290.             Modes[Mode].mode.height / 14, Modes[Mode].mode.nrows );
  291.         printf( Handle, "0 -%d translate\r\n",
  292.             Modes[Mode].mode.nrows );
  293.     } else {            // plain
  294.         printf( Handle, "%%!PS-Adobe-2.0\r\n"
  295.             "gsave 90 rotate "
  296.             "72 -72 translate "
  297.             "%d %d div -%d %d div scale\r\n",
  298.             Modes[Mode].mode.width / 14, Modes[Mode].mode.ncols,
  299.             Modes[Mode].mode.height / 14, Modes[Mode].mode.nrows );
  300.     }
  301.     write( Handle, "/S0 1000 def /S1 S0 def /S2 false def\r\n"
  302.         "/S { /S1 S0 def S2 { stroke } { newpath } ifelse /S2 false def 0 0 moveto } bind def\r\n"
  303.         "/FLUSH { /S1 S1 1 sub def S1 0 le { C S moveto } if } bind def\r\n"
  304.         "/C { currentpoint } bind def\r\n"
  305.         "/L { lineto /S2 true def FLUSH } bind def\r\n"
  306.         "/M { moveto FLUSH } bind def\r\n"
  307.         "2 setlinecap 0 setlinejoin\r\n"
  308.         "0 0 M\r\n"        // avoid /nocurrentpoint
  309.         "%% End of header\r\n");
  310. }
  311.  
  312. void    clear()
  313. {
  314.     printf( Handle, "S showpage grestore gsave\r\n");
  315. }
  316.  
  317. void    post()
  318. {
  319.     printf( Handle, "S showpage grestore\r\n"
  320.         "%%%%EOF\r\n");
  321.     if( Handle != STDOUT )
  322.         close( Handle );
  323. }
  324.  
  325. void    move( INT x, INT y )
  326. {
  327.     printf( Handle, "%d %d M\r\n", x, y );
  328. }
  329.  
  330. void    draw( INT x, INT y )
  331. {
  332.     printf( Handle, "%d %d L\r\n", x, y );
  333. }
  334.  
  335. void    vect( INT x0, INT y0, INT x1, INT y1 )
  336. {
  337.     printf( Handle, "C %d %d M %d %d L M\r\n", x0, y0, x1, y1 );
  338. }
  339.  
  340. void    patbar( INT x0, INT y0, INT x1, INT y1 )
  341. {
  342.     printf( Handle, "gsave %d %d M %d %d L %d %d L %d %d L closepath ",
  343.         x0, y0, x0, y1, x1, y1, x1, y0 );
  344.     fill();
  345.     printf( Handle, "grestore\r\n");
  346. }
  347.  
  348. void    doarc( int a0, int a1, int xrad, int yrad )
  349. {
  350.     printf( Handle, "C gsave newpath 1 %d %d div scale "
  351.         "%d %d %d arc stroke grestore\r\n",
  352.         yrad, xrad, a0, a1, xrad );
  353. }
  354.  
  355. void    arc( INT a0, INT a1, INT xrad, INT yrad )
  356. {
  357.     doarc( a0, a1, xrad, yrad );
  358. }
  359.  
  360. void    dopieslice( int a0, int a1, int xrad, int yrad )
  361. {
  362.     doarc( a0, a1, xrad, yrad );
  363.     printf( Handle, "gsave 1 %d %d div scale "
  364.         "%d %d %d arc closepath ",
  365.         yrad, xrad, a0, a1, xrad );
  366.     fill();
  367.     printf( Handle, "grestore\r\n");
  368. }
  369.  
  370. void    pieslice( INT a0, INT a1, INT xrad, INT yrad )
  371. {
  372.     dopieslice( a0, a1, xrad, yrad );
  373. }
  374.  
  375. void    filledellipse( INT xrad, INT yrad )
  376. {
  377.     dopieslice( 0, 360, xrad, yrad );
  378. }
  379.  
  380. void    palette( INT index, INT red, INT green, INT blue )
  381. {
  382.     if( index == 0xffff )
  383.     {
  384.         Fill.red = red;
  385.         Fill.red = green;
  386.         Fill.red = blue;
  387.     } else {
  388.         Colors[index & 0xff].red = red;
  389.         Colors[index & 0xff].green = green;
  390.         Colors[index & 0xff].blue = blue;
  391.     }
  392. }
  393.  
  394. void    allpalette()
  395. {
  396. }
  397.  
  398. void    color( REG colors )
  399. {
  400.     setcolor( Colors[colors.b[0]] );
  401.     Fill = Colors[colors.b[1]];
  402. }
  403.  
  404. void    fillstyle( BYTE PatNum, INT, INT, INT, CP NewPattern )
  405. {
  406.     static PATTERN    Default[] = {
  407.         "\x00\x00\x00\x00\x00\x00\x00\x00",
  408.         "\xff\xff\xff\xff\xff\xff\xff\xff",
  409.         "\xff\xff\x00\x00\xff\xff\x00\x00",
  410.         "\x01\x02\x04\x08\x10\x20\x40\x80",
  411.         "\xe0\xc1\x83\x07\x0e\x1c\x38\x70",
  412.         "\xf0\x78\x3c\x1e\x0f\x87\xc3\xe1",
  413.         "\xa5\xd2\x69\xb4\x5a\x2d\x96\x4b",
  414.         "\xff\x88\x88\x88\xff\x88\x88\x88",
  415.         "\x81\x42\x24\x18\x18\x24\x42\x81",
  416.         "\xcc\x33\xcc\x33\xcc\x33\xcc\x33",
  417.         "\x80\x00\x08\x00\x80\x00\x08\x00",
  418.         "\x88\x00\x22\x00\x88\x00\x22\x00"
  419.         };
  420.     byte    far *Pattern;
  421.  
  422.     if( PatNum <= sizeof(Default)/sizeof(PATTERN) )
  423.         Pattern = Default[PatNum];
  424.     else    Pattern = NewPattern;
  425.  
  426.     printf( Handle, "%% /Pattern << /PaintType 1 /PatternType 1 /TilingType 1 "
  427.         "/BBox [0 0 8 8] /XStep 8 /YStep 8 /PaintProc { 8 8 1 matrix <");
  428.     for( int i = 0; i < PATLEN; i++ )
  429.         puthex( Pattern[i] );
  430.     printf( Handle, "> image } matrix makepattern def\r\n");
  431. }
  432.  
  433. void    linestyle( BYTE patnum, INT style, INT width )
  434. {
  435.     static unsigned    patterns[] = { 0xffff, 0xcccc, 0xfc78, 0xf8f8 };
  436.     unsigned    pattern, j = 1, count = 0;
  437.  
  438.     if( patnum <= 3 )
  439.         pattern = patterns[patnum];
  440.     else    pattern = style;
  441.  
  442.     printf( Handle, "S [ ");
  443.     if( !(pattern & 0x8000) )
  444.         printf( Handle, "0 ");
  445.     for( int i = 0; i < 16; i++, j++, pattern <<= 1 )
  446.     if( (pattern & 0xc000) == 0x8000 || (pattern & 0xc000) == 0x4000 )
  447.         printf( Handle, "%d ", j ), j = 0, count++;
  448.     if( j > 1 )
  449.         printf( Handle, "%d ", j - 1 ), count++;
  450.     if( count & 1 )
  451.         printf( Handle, "0 ");
  452.     printf( Handle, "] 0 setdash %d setlinewidth\r\n", width );
  453. }
  454.  
  455. void    textstyle( REG num_dir, INT xsize, INT ysize )
  456. {
  457.     FDir = num_dir.b[1] * 90;
  458.     FFirst = 1;
  459.     FXsize = xsize;
  460.     FYsize = ysize;
  461. }
  462.  
  463. void    putstring( int length, char far *string )
  464. {
  465.     char    special[] = "()\\";
  466.  
  467.     printf( Handle, "(");
  468.     for( int i = 0; i < length; i++ )
  469.     {
  470.         for( int s = 0; special[s]; s++ )
  471.         if( string[i] == special[s] )
  472.          {
  473.             printf( Handle, "\\");
  474.             break;
  475.         }
  476.         printf( Handle, "%c", string[i] );
  477.     }
  478.     printf( Handle, ") ");
  479. }
  480.  
  481. void    text( INT, INT, INT length, INT, CP string )
  482. {
  483.     if( FFirst )
  484.     {
  485.         printf( Handle, "/Helvetica findfont %d [ 1 0 0 1 0 0 ] rotate "
  486.             "[ %d 0 0 -%d 0 0 ] dup concatmatrix "
  487.             "makefont setfont\r\n",
  488.             FDir, FXsize, FYsize );
  489.         FFirst = 0;
  490.     }
  491.     putstring( length, string );
  492.     printf( Handle, "show\r\n");
  493. }
  494.  
  495. #pragma warn    -par
  496. void    textsiz( INT, INT width, INT length, INT, FP string )
  497. {
  498.     width = FXsize * length;
  499.     length = FYsize;
  500. }
  501. #pragma warn    .par
  502.  
  503. #pragma warn    -par
  504. void    reserved( INT ax, INT bx, INT cx, INT dx, FP es_bx )
  505. {
  506. }
  507. #pragma warn    .par
  508.  
  509. void    floodfill()
  510. {
  511.     printf( Handle, "%% floodfill: Not implemented\r\n");
  512. }
  513.  
  514. int    dogetpixel()
  515. {
  516.     printf( Handle, "%% getpixel: Not implemented\r\n");
  517.     return    0;
  518. }
  519.  
  520. void    getpixel( INT, INT, INT, INT color )
  521. {
  522.     color = dogetpixel();
  523. }
  524.  
  525. void    doputpixel( int x, int y, int color )
  526. {
  527.     printf( Handle, "gsave ");
  528.     setcolor( Colors[color] );
  529.     printf( Handle, "%d %d M %d.001 %d L stroke grestore\r\n", x, y, x, y );
  530. }
  531.  
  532. void    putpixel( INT x, INT y, INT, BYTE color )
  533. {
  534.     doputpixel( x, y, color );
  535. }
  536.  
  537. void    getimage()
  538. {
  539.     printf( Handle, "%% getimage: Not implemented\r\n");
  540. }
  541.  
  542. void    putimage( INT, INT, INT x, INT y, IMAGE far * _ss &image )
  543. {
  544.     char far    *p = image->data;
  545.  
  546.     printf( Handle, "gsave %d %d 8 %d %d matrix translate { <",
  547.         image->width, image->height, -x, -y );
  548.     for( int i = 0; i < image->height; i++ )
  549.     for( int j = 0; j < image->width; j++ )
  550.         puthex( *p++ );
  551.     printf( Handle, "> } image grestore\r\n");
  552. }
  553.  
  554. void    setclip( INT x0, INT y0, INT x1, INT y1 )
  555. {
  556.     printf( Handle, "C S %d %d M %d %d L %d %d L %d %d L closepath clip newpath M\r\n",
  557.         x0, y0, x0, y1, x1, y1, x1, y0 );
  558. }
  559.  
  560. void    colorquery( BYTE query, INT size, INT maxcol, INT, FP table )
  561. {
  562.     static char    ColTable[] = { 0 };
  563.  
  564.     switch( query )
  565.     {
  566.     case 0:                // get sizes
  567.         size = ColTable[0];
  568.         maxcol = 0xff;
  569.         break;
  570.     case 1:                // get table
  571.         table = &ColTable;
  572.     }
  573. }
  574.  
  575. void    _putpixel( int x, int y, byte color )
  576. {
  577.     doputpixel( x, y, color );
  578. }
  579.  
  580. int    _getpixel()
  581. {
  582.     return    dogetpixel();
  583. }
  584.  
  585. int    _getpixelwidth()
  586. {
  587.     return    0;
  588. }
  589.  
  590. void    _setwritemode()
  591. {
  592.     printf( Handle, "%% setwritemode: Not implemented\r\n");
  593. }
  594.  
  595. HANDLER    dispatch[] = {
  596.     (HANDLER) install,
  597.     (HANDLER) init,
  598.     (HANDLER) clear,
  599.     (HANDLER) post,
  600.     (HANDLER) move,
  601.     (HANDLER) draw,
  602.     (HANDLER) vect,
  603.     (HANDLER) emulate,
  604.     (HANDLER) emulate,        // bar
  605.     (HANDLER) patbar,
  606.     (HANDLER) arc,
  607.     (HANDLER) pieslice,
  608.     (HANDLER) filledellipse,
  609.     (HANDLER) palette,
  610.     (HANDLER) allpalette,
  611.     (HANDLER) color,
  612.     (HANDLER) fillstyle,
  613.     (HANDLER) linestyle,
  614.     (HANDLER) textstyle,
  615.     (HANDLER) text,
  616.     (HANDLER) textsiz,
  617.     (HANDLER) reserved,
  618.     (HANDLER) floodfill,
  619.     (HANDLER) getpixel,
  620.     (HANDLER) putpixel,
  621.     (HANDLER) bitmaputl,
  622.     (HANDLER) getimage,
  623.     (HANDLER) putimage,
  624.     (HANDLER) setclip,
  625.     (HANDLER) colorquery };
  626.  
  627. HANDLER    fardispatch[] = {
  628.     (HANDLER) _putpixel,
  629.     (HANDLER) _getpixel,
  630.     (HANDLER) _getpixelwidth,
  631.     (HANDLER) _setwritemode };
  632.